package service

import (
	"context"
	emodel "engine/model"
	"errors"
	"fmt"
	"github.com/goccy/go-json"
	"github.com/hibiken/asynq"
	"gorm.io/gorm"
	"lib/db"
	"lib/log"
	"time"
)

func HandleSendEmailTask(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendEmailPayload
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var myUser emodel.My_user
		txErr := tx.Where("id=?", p.UserId).First(&myUser).Error
		if txErr != nil {
			return txErr
		}

		txErr = CreateUserPointLog(tx, myUser, p.Money, 10, 0, "游戏奖励：【"+p.Content+"】")
		if txErr != nil {
			return txErr
		}

		//备用积分？
		//if myUser.IsTask == 0 && myUser.DyTure == 1 {
		//	myUserMoble := myUser.Mobile[:3] + "****" + myUser.Mobile[len(myUser.Mobile)-4:]
		//	if myUser.Pid > 0 {
		//		var pUser emodel.My_user
		//		txErr = tx.Where("id=?", myUser.Pid).First(&pUser).Error
		//		if txErr != nil {
		//			return txErr
		//		}
		//
		//		txErr = CreateUserScoreLog(tx, pUser, 1, 4, 0, "直推"+myUserMoble+"成为有效用户")
		//		if txErr != nil {
		//			return txErr
		//		}
		//	}
		//	if myUser.Ppid > 0 {
		//		var pPUser emodel.My_user
		//		txErr = tx.Where("id=?", myUser.Ppid).First(&pPUser).Error
		//		if txErr != nil {
		//			return txErr
		//		}
		//
		//		txErr = CreateUserScoreLog(tx, pPUser, 0.5, 4, 0, "间推"+myUserMoble+"成为有效用户")
		//		if txErr != nil {
		//			return txErr
		//		}
		//	}
		//
		//}

		return nil
	})
	if err != nil {
		log.Errorf("notify : %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleUserLevel(ctx context.Context, t *asynq.Task) error {
	var p emodel.SendUserLevel
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	err = db.GetDb().Debug().Transaction(func(tx *gorm.DB) error {
		var levelUser []emodel.My_user_levels
		if err = tx.Where("days=? and is_now = 0  and is_cli=0 and uid=?", p.Days, p.UserId).Find(&levelUser).Error; err != nil {
			log.Errorf("NotifyLevelHandel error err:", err)
			return err
		}

		if len(levelUser) > 0 {

			newScoreAll := make([]emodel.My_user_score_log, 0)
			//设置每个用户的id 订
			var myUser emodel.My_user
			txErr := tx.Where("id=?", p.UserId).First(&myUser).Error
			if txErr != nil {
				return txErr
			}

			var addMoney float64
			userMoney := myUser.Money
			for _, levelInfo := range levelUser {
				////给我加钱？
				myUserlog := emodel.My_user_score_log{
					Memo:       fmt.Sprintf("参加%d级阶梯的成本", levelInfo.Levels),
					UserId:     myUser.Id,
					Score:      levelInfo.Num,
					Before:     userMoney,
					After:      userMoney + levelInfo.Num,
					Mobile:     myUser.Mobile,
					Aid:        myUser.Id,
					Createtime: time.Now().Format("2006-01-02T15:04:05"),
					Flag:       3,
				}
				newScoreAll = append(newScoreAll, myUserlog)
				myUserlogFen := emodel.My_user_score_log{
					Memo:       fmt.Sprintf("参加%d级阶梯的分红", levelInfo.Levels),
					UserId:     myUser.Id,
					Score:      levelInfo.ZNum - levelInfo.Num,
					Before:     myUserlog.After,
					After:      userMoney + levelInfo.ZNum,
					Mobile:     myUser.Mobile,
					Aid:        myUser.Id,
					Createtime: time.Now().Format("2006-01-02T15:04:05"),
					Flag:       3,
				}
				newScoreAll = append(newScoreAll, myUserlogFen)

				userMoney = userMoney + levelInfo.ZNum
				addMoney = addMoney + levelInfo.ZNum
			}

			if addMoney > 0 {
				txErr = tx.Exec("update my_user set money=money+? where id=? ", addMoney, p.UserId).Error
				if txErr != nil {
					return txErr
				}
			}

			if txErr = tx.Table("my_user_levels").Where("days=? and is_now = 0  and is_cli=0 and uid=?", p.Days, p.UserId).UpdateColumn("is_cli", 1).Error; txErr != nil {
				return txErr
			}
			//批量增加记录吧
			if len(newScoreAll) > 0 {

				EsCreateUserLogDataAll(newScoreAll)
			}
		}
		return nil
	})
	if err != nil {
		log.Errorf("UpdateOldLevel error: %v", err)
		return err
	}
	return nil
}
func HandleUserLevelNew(ctx context.Context, t *asynq.Task) error {
	var p emodel.SendUserLevelNow
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	err = db.GetDb().Debug().Transaction(func(tx *gorm.DB) error {
		var levelInfo emodel.My_level_his
		if err = tx.Where(" is_cli = 0 and id=?", p.Id).Find(&levelInfo).Error; err != nil {
			log.Errorf("NotifyLevelHandel error err:", err)
			return err
		}
		var myUser emodel.My_user
		txErr := tx.Where("id=?", levelInfo.Uid).First(&myUser).Error
		if txErr != nil {
			return txErr
		}
		var num float64
		if levelInfo.Index > 50 { //5000
			num = 100
		} else if levelInfo.Index > 30 { //4000
			num = 200
		} else if levelInfo.Index > 10 { //3000
			num = 300
		} else if levelInfo.Index > 3 { //400
			num = 400
		} else if levelInfo.Index == 3 {
			num = 500
		} else if levelInfo.Index == 2 {
			num = 700
		} else if levelInfo.Index == 1 {
			num = 1000
		}

		////给我加钱？
		myUserLog := emodel.My_user_score_log{
			Memo:       fmt.Sprintf("阶梯榜奖励 名次%d", levelInfo.Index),
			UserId:     myUser.Id,
			Score:      num,
			Before:     myUser.Point,
			Type:       2,
			After:      myUser.Point + num,
			Mobile:     myUser.Mobile,
			Aid:        myUser.Id,
			Flag:       16,
			Createtime: time.Now().Format("2006-01-02T15:04:05"),
		}
		EsCreateUserLogData(myUserLog)

		txErr = tx.Exec("update my_user set point=point+? where id=? ", num, myUser.Id).Error
		if txErr != nil {
			return txErr
		}

		txErr = tx.Table("my_level_his").Where("id=?", levelInfo.Id).UpdateColumn("is_cli", 1).Error
		if txErr != nil {
			return txErr
		}
		//errs := tx.Debug().Omit("createtime").Create(&myUserlog).Error
		//if errs != nil {
		//	log.Errorf("NotifyLevelHandel error err:", errs)
		//	return errs
		//}
		//EsCreateData(myUserlog)

		return nil
	})
	if err != nil {
		log.Errorf("UpdateOldLevel error: %v", err)
		return err
	}

	//更改es也加记录的

	return nil
}

func HandleUserLevelNewOrder(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendUserLevelNow
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	err = db.GetDb().Debug().Transaction(func(tx *gorm.DB) error {
		var levelInfo emodel.My_order_his

		if err = tx.Where(" is_cli = 0 and id=?", p.Id).Find(&levelInfo).Error; err != nil {
			log.Errorf("NotifyLevelHandel error err:", err)
			return err
		}

		var myUser emodel.My_user
		txErr := tx.Where("id=?", levelInfo.Uid).First(&myUser).Error
		if txErr != nil {
			return txErr
		}
		var num float64
		if levelInfo.Index > 50 { //5000
			num = 200
		} else if levelInfo.Index > 30 { //4000
			num = 400
		} else if levelInfo.Index > 10 { //3000
			num = 600
		} else if levelInfo.Index > 3 { //400
			num = 800
		} else if levelInfo.Index == 3 {
			num = 1000
		} else if levelInfo.Index == 2 {
			num = 1400
		} else if levelInfo.Index == 1 {
			num = 2000
		}

		////给我加钱？
		myUserLog := emodel.My_user_score_log{
			Memo:       fmt.Sprintf("订单榜奖励 名次%d", levelInfo.Index),
			UserId:     myUser.Id,
			Score:      num,
			Before:     myUser.Point,
			Type:       2,
			After:      myUser.Point + num,
			Mobile:     myUser.Mobile,
			Aid:        myUser.Id,
			Flag:       16,
			Createtime: time.Now().Format("2006-01-02T15:04:05"),
		}

		EsCreateUserLogData(myUserLog)

		txErr = tx.Exec("update my_user set point=point+? where id=? ", num, myUser.Id).Error
		if txErr != nil {
			return txErr
		}

		txErr = tx.Table("my_order_his").Where("id=?", levelInfo.Id).UpdateColumn("is_cli", 1).Error
		if txErr != nil {
			return txErr
		}

		return nil
	})
	if err != nil {
		log.Errorf("UpdateOldLevel error: %v", err)
		return err
	}

	//更改es也加记录的
	return nil
}

func HandleXuanshangTask(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendEmailPayload
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var myUser emodel.My_user
		txErr := tx.Where("id=?", p.UserId).First(&myUser).Error
		if txErr != nil {
			return txErr
		}
		txErr = CreateUserPointLog(tx, myUser, p.Money, 20, 0, "悬赏奖励：【"+p.Content+"】")
		if txErr != nil {
			return txErr
		}
		return nil
	})
	if err != nil {
		log.Errorf("notify : %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleZhunshouTask(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendZhushouPayload
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	//获取订单状态 如果是已结算 那么更新成已完成
	//如果是待支付  1待支付 7已取消  8已退款 10待使用 那么认为订单是关闭了的
	accessToken, err := GetWxDaiHuoAccessToken()
	if err != nil {
		return err
	}
	flag, err := GetYongjinDetai(accessToken, p.OrderNo, p.Skuids)

	//更改订单状态 订单异常

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var ddd emodel.My_online_order_levels
		if err = tx.Where("id=?", p.Id).First(&ddd).Error; err != nil {
			return err
		}
		if ddd.Status != 0 {
			log.Errorf("var ddd emodel.My_online_order_levels 非法操作")
			return errors.New("非法操作")
		}

		if flag == 0 {
			err = tx.Table("my_online_order_levels").Where("id=?", p.Id).Updates(map[string]interface{}{
				"status":     3,
				"sh_content": err.Error(),
				"sy_time":    time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			return nil
		}
		if flag == 4 {
			err = tx.Table("my_online_order_levels").Where("id=?", p.Id).Updates(map[string]interface{}{
				"status":     1,
				"sh_content": "已完成",
				"sy_time":    time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			return nil
		}
		if flag == 2 { //失败 扣除50积分
			err = tx.Table("my_online_order_levels").Where("id=?", p.Id).Updates(map[string]interface{}{
				"status":     2,
				"sh_content": "阶梯订单违规处罚",
				"sy_time":    time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			var user emodel.My_user
			txErr := tx.Where("id=?", p.Uid).First(&user).Error
			if txErr != nil {
				return txErr
			}
			txErr = CreateUserLog(tx, user, 50, 41, 0, "阶梯订单违规处罚")
			if txErr != nil {
				return txErr
			}
			return nil
		}

		return nil
	})
	if err != nil {
		//未找到订单 订单异常
		log.Errorf("notify : %v", string(t.Payload()))
		return err
	}
	return nil
}
func HandleZhunshouTaskWx(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendZhushouPayload
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	//获取订单状态 如果是已结算 那么更新成已完成
	//如果是待支付  1待支付 7已取消  8已退款 10待使用 那么认为订单是关闭了的
	accessToken, err := GetWxDaiHuoAccessToken()
	if err != nil {
		return err
	}
	flag, err := GetYongjinDetai(accessToken, p.OrderNo, p.Skuids)

	//更改订单状态 订单异常

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var ddd emodel.My_order_w
		if err = tx.Where("id=?", p.Id).First(&ddd).Error; err != nil {
			return err
		}
		if ddd.Flag != 0 && ddd.Status != 0 {
			log.Errorf("var ddd emodel.My_order_w 非法操作")
			return errors.New("非法操作")
		}

		if flag == 0 {
			err = tx.Table("my_order_w").Where("id=?", p.Id).Updates(map[string]interface{}{
				"flag":       3,
				"status":     2,
				"sh_content": "未找到数据",
				"sy_time":    time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			return nil
		}
		if flag == 4 {
			err = tx.Table("my_order_w").Where("id=?", p.Id).Updates(map[string]interface{}{
				"flag":    1,
				"sy_time": time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			return nil
		}
		if flag == 2 { //失败 扣除50积分
			err = tx.Table("my_order_w").Where("id=?", p.Id).Updates(map[string]interface{}{
				"flag":       2,
				"status":     2,
				"sh_content": "阶梯订单违规处罚",
				"sy_time":    time.Now().Format("2006-01-02 15:04:05"),
			}).Error
			if err != nil {
				return err
			}
			var user emodel.My_user
			txErr := tx.Where("id=?", p.Uid).First(&user).Error
			if txErr != nil {
				return txErr
			}
			//txErr = CreateUserLog(tx, user, 50, 41, 0, "阶梯订单违规处罚")
			//if txErr != nil {
			//	return txErr
			//}
			return nil
		}

		return nil
	})
	if err != nil {
		//未找到订单 订单异常
		log.Errorf("notifyww : %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleDingdanLevelTask(ctx context.Context, t *asynq.Task) error {

	var p emodel.SendDingdanLevelload
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	//获取订单状态 如果是已结算 那么更新成已完成
	//如果是待支付  1待支付 7已取消  8已退款 10待使用 那么认为订单是关闭了的

	//更改订单状态 订单异常

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var ddd emodel.My_online_order_levels
		if err = tx.Where("id=?", p.Id).First(&ddd).Error; err != nil {
			return err
		}
		if ddd.Status != 1 || ddd.Jj != 0 {
			log.Errorf("var ddd emodel.My_online_order_levels 非法操作")
			return errors.New("非法操作")
		}

		var user emodel.My_user
		txErr := tx.Select("point", "id", "mobile").Where("id=?", p.Uid).First(&user).Error
		if txErr != nil {
			return txErr
		}

		txErr = tx.Table("my_online_order_levels").Where("id=?", p.Id).Update("jj", p.Num).Error
		if txErr != nil {
			return txErr
		}

		txErr = CreateUserPointLog(tx, user, float64(p.Num), 35, 0, "阶梯订单奖励")
		if txErr != nil {
			return txErr
		}

		return nil
	})
	if err != nil {
		//未找到订单 订单异常
		log.Errorf("notify : %v", string(t.Payload()))
		return err
	}
	return nil
}
func HandleDingdanLevelTaskGame(ctx context.Context, t *asynq.Task) error {

	var p emodel.My_game_day
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}
	//获取订单状态 如果是已结算 那么更新成已完成
	//如果是待支付  1待支付 7已取消  8已退款 10待使用 那么认为订单是关闭了的

	//更改订单状态 订单异常

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {

		var user emodel.My_user
		txErr := tx.Where("id=?", p.Uid).First(&user).Error
		if txErr != nil {
			return txErr
		}
		p.F = 1
		if txErr := tx.Updates(&p).Error; txErr != nil {
			return txErr
		}

		txErr = CreateTzLog(tx, user, float64(p.Jl), 36, 0, "游戏奖励")
		if txErr != nil {
			return txErr
		}

		return nil
	})
	if err != nil {
		//未找到订单 订单异常
		log.Errorf("notify  HandleDingdanLevelTaskGame : %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleChanChu(ctx context.Context, t *asynq.Task) error {

	var p emodel.FlishTaskFenhong
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}

	//更改订单状态 订单异常
	var myFlish []emodel.MyMyFlish
	db.GetDb().Select("id", "cl", "f").Where("uid=? and t_days=? and days<? and szq<365",
		p.Uid, p.Days, p.Days,
	).Find(&myFlish)
	if len(myFlish) == 0 {
		return nil
	}
	var ssss *emodel.MyMyFlish
	err = db.GetDb().Transaction(func(tx *gorm.DB) error {

		var user emodel.My_user
		txErr := tx.Where("id=?", p.Uid).First(&user).Error
		if txErr != nil {
			return txErr
		}
		ids := make([]uint64, 0)

		for _, m := range myFlish {

			name := ssss.FuzzName(m.F)
			//循环加钱 加记录
			txErr = CreateTzLog(tx, user, float64(m.Cl), 51, 0, fmt.Sprintf("养鱼分红 %s", name))
			if txErr != nil {
				return txErr
			}
			user.Tz = user.Tz + m.Cl
			ids = append(ids, m.Id)
		}
		//批量更改
		tx.Exec("update my_my_flish set ycl=ycl+cl,szq=szq+1,days=? where id in(?) ", p.Days, ids)
		return nil
	})
	if err != nil {
		//未找到订单 订单异常
		log.Errorf("notify  HandleDingdanLevelTaskGame : %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleFenhongAddMoeny(ctx context.Context, t *asynq.Task) error {

	var p emodel.UserAddMoney
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}

	if p.Uid <= 0 {
		return nil
	}
	//更改订单状态 订单异常
	//var myFlish emodel.My_user
	//db.GetDb().Select("id", "tz").Where("id=? and fh<",
	//	p.Uid, p.Days,
	//).First(&myFlish)
	//if myFlish. == 0 {
	//	return nil
	//}
	err = db.GetDb().Transaction(func(tx *gorm.DB) error {
		var myUser emodel.My_user
		txErr := tx.Select("tz", "sl", "id", "mobile").Where("id=?", p.Uid).First(&myUser).Error
		if txErr != nil {
			return txErr
		}
		if p.Type == 0 {
			txErr = CreateTzLog(tx, myUser, p.Num, p.Flag, myUser.Id, p.Str)
		} else if p.Type == 1 {
			txErr = CreateSlLog(tx, myUser, p.Num, p.Flag, myUser.Id, p.Str)
		}
		if txErr != nil {
			return txErr
		}
		//批量更改
		return nil
	})

	if err != nil {
		db.GetDb().Exec("update my_user set fh=-1  where  id =?", p.Uid)
		//未找到订单 订单异常
		log.Errorf("notify 11 HandleDingdanLevelTaskGame 111: %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleFenhong(ctx context.Context, t *asynq.Task) error {

	var p emodel.FlishTaskFenhong
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}

	if p.Uid <= 0 {
		return nil
	}
	//更改订单状态 订单异常
	//var myFlish emodel.My_user
	//db.GetDb().Select("id", "tz").Where("id=? and fh<",
	//	p.Uid, p.Days,
	//).First(&myFlish)
	//if myFlish. == 0 {
	//	return nil
	//}

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {

		var user emodel.My_user
		txErr := tx.Select("tz", "mobile", "fh", "id").Where("id=?", p.Uid).First(&user).Error
		if txErr != nil {
			return txErr
		}

		if user.Id == 0 {
			return errors.New("id错误")
		}
		if user.Fh >= p.Days {
			return errors.New("一级龙过了")
		}
		if user.Tz < 1 {
			return errors.New("未满足条件")
		}

		//循环加钱 加记录
		txErr = CreateSlLog(tx, user, float64(user.Tz*0.6), 4, 0, "余额生息")
		if txErr != nil {
			return txErr
		}

		tx.Exec("update my_user set fh=?  where  id =?", p.Days, p.Uid)
		//批量更改
		return nil
	})

	if err != nil {
		db.GetDb().Exec("update my_user set fh=-1  where  id =?", p.Uid)
		//未找到订单 订单异常
		log.Errorf("notify  HandleDingdanLevelTaskGame 111: %v", string(t.Payload()))
		return err
	}
	return nil
}

func HandleFenhongFlish(ctx context.Context, t *asynq.Task) error {

	var p emodel.FlishTaskFenhong
	err := json.Unmarshal(t.Payload(), &p)
	if err != nil {
		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
	}

	if p.Uid <= 0 {
		return nil
	}
	//更改订单状态 订单异常
	//var myFlish emodel.My_user
	//db.GetDb().Select("id", "tz").Where("id=? and fh<",
	//	p.Uid, p.Days,
	//).First(&myFlish)
	//if myFlish. == 0 {
	//	return nil
	//}

	err = db.GetDb().Transaction(func(tx *gorm.DB) error {

		var user emodel.My_user
		txErr := tx.Select("sl", "mobile", "ks_his", "is_task", "id").Where("id=?", p.Uid).First(&user).Error
		if txErr != nil {
			return txErr
		}

		if user.Id == 0 {
			return errors.New("id错误")
		}
		if user.KsHis >= p.Days {
			return errors.New("一级龙过1了")
		}
		if user.IsTask < 1 {
			return errors.New("未满足条件")
		}

		//循环加钱 加记录
		txErr = CreateSlLog(tx, user, p.Num, 11, 0, "养鱼奖励")
		if txErr != nil {
			return txErr
		}

		tx.Exec("update my_user set ks_his=?  where  id =?", p.Days, p.Uid)
		//批量更改
		return nil
	})

	if err != nil {
		db.GetDb().Exec("update my_user set ks_his=-1  where  id =?", p.Uid)
		//未找到订单 订单异常
		log.Errorf("notify  HandleDingdanLevelTaskGame 11122111: %v", string(t.Payload()))
		return err
	}
	return nil
}
